.TH std::chrono::is_clock 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::chrono::is_clock \- std::chrono::is_clock

.SH Synopsis
   Defined in header <chrono>
   template< class T >         \fI(since C++20)\fP
   struct is_clock;

   If T satisfies the Clock requirements, provides the member constant value equal
   true. For any other type, value is false.

   For the purpose of this trait, the extent to which an implementation determines that
   a type cannot meet the Clock requirements is unspecified, except that a minimum T
   shall not qualify as a Clock unless it meets all following conditions:

     * Each of the following qualified identifiers is valid and denotes a type:

     * T::rep
     * T::period
     * T::duration
     * T::time_point
     * Each of the following expressions is well-formed when treated as an unevaluated
       operand:

     * T::is_steady
     * T::now()

   If the program adds specializations for std::is_clock or std::is_clock_v, the
   behavior is undefined.

.SH Template parameters

   T - a type to check

   Helper variable template

   template< class T >                                     \fI(since C++20)\fP
   inline constexpr bool is_clock_v = is_clock<T>::value;



Inherited from std::integral_constant

.SH Member constants

   value    true if T satisfies the Clock requirements, false otherwise
   \fB[static]\fP \fI(public static member constant)\fP

.SH Member functions

   operator bool converts the object to bool, returns value
                 \fI(public member function)\fP
   operator()    returns value
   \fI(C++14)\fP       \fI(public member function)\fP

.SH Member types

   Type       Definition
   value_type bool
   type       std::integral_constant<bool, value>

.SH Possible implementation

   template<class>
   struct is_clock : std::false_type {};

   template<class T>
       requires
           requires
           {
               typename T::rep;
               typename T::period;
               typename T::duration;
               typename T::time_point;
               T::is_steady; // not required to be bool
               T::now();     // not required to be T::time_point
           }
   struct is_clock<T> : std::true_type {};

.SH Example


// Run this code

 #include <chrono>
 #include <ratio>

 int main()
 {
     static_assert
     (
         std::chrono::is_clock_v<std::chrono::utc_clock>
         and
         not std::chrono::is_clock_v<std::chrono::duration<int, std::exa>>
     );
 }
